Languguage OS 2/Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO/a_utils/debugger/amiga/powervsr.rdm

Text File | 1992-02-17 | 12KB | 151 lines

This is PowerVisor, a powerful machinelanguage level debugger
for the serious Amiga programmer.

This is an update to PV V1.10 beta. Many bugs have been fixed and
some new features are added.
This is version V1.13 beta. (notice ! still beta)

Below follows a list of features.
PowerVisor is shareware. Read the 'ReadThisFile' file in the
root of the zoo file for more info.

Warning ! This is still a beta version. Although a very
stable one I think.


Some PowerVisor features :

- Compatible with all Amiga models and all Motorola processors that
  you can put in your Amiga (68000,68010,68020,68030,68881,68882,
  68851). (The disassembler also supports the 68040).
- Full screen debugger or commandline type debugger all in one.
  This new version even has a primitive source level debugger
  (for C and assembler).
- Very configurable, you can redefine the keys (for example to
  emulate the monam2 keys).
  You can attach almost any command to almost any key.
- Two versions : one for AmigaDOS 1.2-1.3 and one for AmigaDOS 2.0.
- The following singlestep commands are supported :
    - simple trace
    - trace over BSR/JSR (works even in ROM)
    - trace until register changes (done in singlestepmode)
    - trace until branch (stops tracing before branch really
      executes) (done in singlestepmode).
    - trace until operating system call used (JSR (a6) or JMP (a6))
      (done in singlestepmode).
    - trace until address (with automatic breakpoint).
    - trace until condition becomes true (with a powerful expression
      evaluator, you could for example trace until register d0 is
      equal to d1 and d2 is equal to d3) (done in singlestep mode).
- The following breakpoints are supported :
    - break
    - break and remove breakpoint
    - break after <n> times
    - break if condition is true
    - profile breakpoint (counter)
- The number of breakpoints is unlimited (only limited by memory).
- When you are tracing a program you can continue typing commands.
  You can even singlestep more commands at the same time (multitasking
  debugging).
- SYMBOL hunks are supported.
- You can interactivelly add or remove symbols so you can more easily
  remember routines to jump to.
- You can debug crashed tasks, you can load a task, you can simply
  take a task from the task list to debug it or you can wait until
  the next task is started.
- ARexx port. You can write your scripts in ARexx.
  This ARexx scripts are asynchronious (multitasking) so you
  can run an ARexx script in one logical window and type commands
  in the other one.
- Simple scripts can also be written in the internal script
  language.
- You can list several system lists : tasks, locks, files, libraries,
  devices, resources, interrupts, resident modules, dos devices,
  fonts, message ports, semaphores, execbase, graphicsbase,
  intuitionbase, windows, screens, input handlers, memory lists,
  autoconfig devices, ...
- You can ask more information about each element of a list. For
  example you can dump the task structure of an element in the
  task list.
- You can of course view memory and disassemble instructions.
- There is a very powerful 'view' command. You can define
  regions of memory to be of a certain type. The 'view' command
  will then automatically adapts its output to the type of the
  memory. The following types are supported : ascii, byte,
  word, long, code (disassembly) and structures. With the last
  type you can define a region of memory to be a structure. For
  example: with one command you can define all tasks in the system
  as 'STRUCTURE Task'. When the 'view' command accidently hits
  the memory of one task, the output will automatically reflect
  this.
  You can define your own structures to use in PowerVisor.
- You can interactivelly test and use libraries and devices.
  PowerVisor understands fd-files so that you can use the library
  functions in this library as if you type them from C (more
  or less). This is very useful when you want to see how a certain
  library function works.
- PowerVisor traps crashes and gurus (most of them anyway).
- PowerVisor traps stack overflows.
- PowerVisor has 7 different logical windows (these are not
  Intuition windows) for output. One is for the fullscreen debugger,
  one is for the automatic refresh and two are for normal output.
  The other two are for PortPrint output (see later) and for ARexx
  output. The last one is for the source level debugger.
  You can use a different font for any of the logical windows.
- Powerful windowsystem. You can stack Intuitionwindows and
  PowerVisor windows in any way you want.
- Integrated portprint facility (with library), all messages printed
  appear on the PowerVisor window.
- Support for interlace/non interlace.
- PowerVisor uses a 3D screen when started in AmigaDOS 2.0.
  PowerVisor also uses overscan in AmigaDOS 2.0.
- In AmigaDOS 2.0 the PowerVisor screen is a public screen.
  You can make the screen of PowerVisor an autoscrolling
  screen (like the 2.0 WorkBench).
- You can put the PowerVisor window on each screen available in
  the system. This is of course dangerous but it can be useful
  to debug some programs.
- A logical window can be bigger than the visible size. This enables
  you to scroll this window to view the previous output.
- A built-in snap facility.
- A very powerful command parser and expression evaulator.
  Some examples :
    (5*4)<<2                 => 80
    *4                       => pointer to execbase
    *4.b                     => byte at location 4
    {a=5;v a*a}+1            => 26
    *(task:input.device+4)   => contents of task structure
    if(a>=0,a,-a)            => abs(a)
- Online help.
- You can patch each library function in the system to see how
  many times a function is used, by whom it is used, or what
  parameters where given.
- Scratch register kill is also supported starting with PV 1.13.
- Commandline history.
- 'Alias' command.
- MMU commands, you can disassemble the mmu tree, you can reset
  all U and M (used and modify) bits, you can display all 68020
  68030 and the mmu registers. (several bugs have been solved here)
- 'kill' and 'freeze' commands to kill and freeze tasks.
- You can remove a lot of things : tasks, input handlers, windows,
  screens, resident modules, ...
- You can read or write blocks using the trackdisk.device.
- Variables allow you to remember values for later. Very useful
  when debugging.
- Except for the lists and the extra information for each element
  in the list, you can ask other information as well :
    - all gadgets in a window (gadget structure is dumped)
    - hunks for a process
- Redirection of output to a file (log file).
- There are also commands to search, fill and copy memory.
- You can also install a usage counter for each tasks, so that
  you can determine how active a certain task is.
- You can determine maximum stack checking for a task or process
- Uses menus in AmigaDOS 2.0
- Uses reqtools.library for requesters if available (reqtools is
  made by Nico Francois)
- New feature for PV 1.13: primitive resource tracking for AllocMem,
  AllocVec and OpenLibrary

          Jorrit Tyberghein